/**
Gothic - Graphics toolkit<BR>
(28/08/10) creepstudio.dev@gmail.com <BR>
Este programa es GNU/GPL<BR>

¿Otra libreria mas? Quizas sea la pregunta mas frecuente. La respuesta es no, no es una libreria esencialmente. Es un conjunto<BR>
de herramientas que facilitan la tarea de la programacion grafica en c++ usando Gcc. Sobre todo, orientada a los videojuegos.<BR>
<BR>
Se pone enfasis en la presentacion de un codigo limpio, directo y sencillo de recordar. Muchos metodos son de uso parecido en<BR>
las diferentes clases para asi crear una asociacion mas rapida de estos. Esta "caja de herramientas" esta programada usando<BR>
c++ en Gcc, y usando las siguientes librerias:<BR>
 SDL ( _image, _net, _ttf, _mixer )
 OpenGL ( renderizado de graficos, fx )

Estas librerias han de estar ya instaladas en el sistema para poder usar el toolkit. Se ha desarrollado todo usando una<BR>
debian unbuntu lucid. El ide usado ha sido Code::Blocks.<BR>
<BR>
La idea final del toolkit, es la de ayudar en el desarrollo de juegos y aplicaciones graficas usando c++, gcc y esta<BR>
"caja de herramientas", usando ademas toda la potencia del desarrollo orientado a objetos.

@mainpage Gothic - Graphics toolkit
@version 0.1
@author David Gonzalez Gonzalez
@date 28 Aug, 2010
@note Mas info en el weblog, ghtoolkit.wordpress.com <BR>Tambien por email a:
@email creepstudio.dev@gmail.com
*/

#include <stdlib.h>
#include <time.h>
#include <stdio.h>
#include <iostream>
#include <fstream>
#include <cstdlib>

#include <SDL_opengl.h>
#include <SDL_mixer.h>
#include <SDL.h>
#include <SDL_image.h>
#include <SDL_ttf.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <math.h>

#include "ghDef.h"
#ifndef _ghToolkit_h_
#define _ghToolkit_h_

using namespace std;
/**\brief Estructura de 2 variables tipo int */
struct gh2iVector2D {
    int x;
    int y;
};


/**\brief Capa principal de el toolkit */
class ghToolkit {
    private:
    public:

    /**\brief Capa que maneja lo mas elemental de el toolkit */
    class system {
        private:
        SDL_Surface *sdlsWindow;
        Uint32 startclock;
        Uint32 deltaclock;
        Uint32 currentFPS;

        public:
        void init       ( int iMode );
        void window     ( int iWidth, int iHeight, int iBpp );
        void title      ( const char *chTitle );
        void fill       ( float fR, float fG, float fB );
        void clear      ( void );
        void flip       ( void );
        void delay      ( int iSeconds );
         int fps        ( void );
SDL_Surface *getSprite  ( void ) { return sdlsWindow; }
    };

    /**\brief Capa que maneja los metodos de entrada de el toolkit */
    class motion {
        private:
        int mX;
        int mY;
        public:
        SDL_Event sdleHandler;
        int iReturnsignal;

       void setMouse    ( bool bshow );
        int getEvents   ( void );
        int getMouseX   ( void );
        int getMouseY   ( void );
};

    /**\brief Capa que maneja los metodos de las entidades */
    class entity2D {
        private:
        GLuint uiGSprite;
        GLint  nOfColors;
        GLenum texture_format;

        SDL_Surface *sdlsSprite;
        int spX;
        int spY;
        int spW;
        int spH;
        float spcR;
        float spcG;
        float spcB;
        float spS;
        float spA;
        float spP;

        public:
        void load           ( const char *chSprite );
        void draw           ( int iX, int iY );
        void draw           ( gh2iVector2D vect );
        void color          ( float fR, float fG, float fB);
SDL_Surface *getSprite      ( void );
         int getX           ( void );
         int getY           ( void );
         int getWidth       ( void );
         int getHeight      ( void );
         int getAngle       ( void );
         int getScale       ( void );
         int getAlpha       ( void );
        void scale          ( float fScale );
        void angle          ( float fAngle );
        void alpha          ( float fAlpha );
    };
    /**\brief Capa principal de los fx */
    class fx {
        private:
        public:
        void shadow ( ghToolkit::entity2D obj, int iDistance, int iPositionLigth );
    };

    /**\brief Capa que maneja los eventos de el toolkit */
    class event {
        private:
        public:
        int collision ( ghToolkit::entity2D ent_1,  ghToolkit::entity2D ent_2 );
    };

    /**\brief Capa que maneja los metodos de texto de el toolkit */
    class text {
        private:
        TTF_Font *ttfFont;
        SDL_Color colorText;
        SDL_Rect *location;

        public:
        void load   ( const char *chFont );
        void color  ( int iR, int iG, int iB );
        void scale  ( int iScale );
        void angle  ( int iAngle );
        void alpha  ( int iAlpha );
        void write  ( const char *chText, int iX, int iY );
        void write  ( int iVar , int iX, int iY );
    };

    /**\brief Capa que maneja los metodos de sonido de el toolkit */
    class sound {
        private:
Mix_Music *mmMusic;
Mix_Chunk *mmFx;
        int iAudioRate;
        int iAudioChannels;
        int iAudioBuffer;
int i ;
        Uint16 uiAudioFormat;

        public:
        void load   ( const char *chsound );
        void loadfx ( const char *chsoundfx );
        void play   ( int imode );
        void playfx   ( );
        void pause  ( void );

        void resume ( void );
        void stop   ( void );
    };
};



#endif
